// src\lang\index.js
import { createI18n } from 'vue-i18n';
import { i18nLoader } from './i18nloader';
import { useAppStore } from '@/store';

// 默认语言
const DEFAULT_LOCALE = 'zh-cn';

// 创建i18n实例
const i18n = createI18n({
  locale: DEFAULT_LOCALE,
  fallbackLocale: DEFAULT_LOCALE,
  messages: {
    // 初始为空，将通过动态加载填充
  },
  legacy: false, // 使用Composition API模式
  globalInjection: true,
});

/**
 * 增强型翻译函数
 * 支持多种调用方式：
 * 1. smartTranslate('key')
 * 2. smartTranslate('key', '默认文本')
 * 3. smartTranslate('key', { param1: value1, param2: value2 }) // 直接传入插值参数对象
 * 4. smartTranslate('key', '默认文本', { param1: value1, param2: value2 }) // 新增支持：默认文本 + 插值参数
 * 5. smartTranslate('key', '默认文本', { params: { param1: value1 } }) // 原有格式
 * 6. smartTranslate('key', { default: '默认文本', params: { param1: value1 }, fallbackKey: 'another.key' })
 *
 * @param {string} key - 翻译键值
 * @param {string|Object} [arg2] - 可以是默认文本（字符串），也可以是插值参数对象，或者是配置选项对象
 * @param {Object} [arg3] - 配置选项对象或插值参数对象，当arg2为默认文本时使用
 * @param {Object} [arg3.params] - 翻译参数（插值变量），仅当arg3为配置选项对象且params嵌套时
 * @param {string} [arg3.fallbackKey] - 备用的回退键值
 * @param {boolean} [arg3.ignoreMissing] - 是否忽略缺失键的警告
 * @returns {string} 翻译结果
 */
export const smartTranslate = (key, arg2, arg3) => {
  // 获取全局默认配置
  const globalDefaults = getSmartTranslateDefaults();

  let finalDefaultValue = key; // 最终的默认值，如果键不存在则返回
  let finalOptions = { ...globalDefaults }; // 最终的配置选项（如 fallbackKey, ignoreMissing），先应用全局默认值
  let finalInterpolationParams = { ...globalDefaults.globalParams }; // 最终的插值参数，先应用全局默认参数

  // 根据 arg2 的类型和内容来解析参数
  if (typeof arg2 === 'string') {
    // 情况1: smartTranslate('key', '默认文本', ...)
    finalDefaultValue = arg2;

    if (typeof arg3 === 'object' && arg3 !== null) {
      // 检查 arg3 是否是配置选项对象（包含 params, fallbackKey, ignoreMissing 等）
      const isOptionsObject =
        arg3.params !== undefined ||
        arg3.fallbackKey !== undefined ||
        arg3.ignoreMissing !== undefined;

      if (isOptionsObject) {
        // smartTranslate('key', '默认文本', { params: { param1: value1 }, fallbackKey: '...' })
        finalOptions = { ...finalOptions, ...arg3 }; // 合并全局默认值和传入的选项
        finalInterpolationParams = {
          ...finalInterpolationParams,
          ...(arg3.params || {}),
        }; // 合并参数
      } else {
        // smartTranslate('key', '默认文本', { param1: value1, param2: value2 })
        // arg3 直接作为插值参数对象
        finalInterpolationParams = { ...finalInterpolationParams, ...arg3 }; // 合并全局默认参数和传入的参数
      }
    } else {
      // smartTranslate('key', '默认文本') - 没有第三个参数
      // finalOptions 和 finalInterpolationParams 已经包含全局默认值，无需重新设置
    }
  } else if (typeof arg2 === 'object' && arg2 !== null) {
    // 情况2: smartTranslate('key', { ...optionsOrParams })
    // 判断 arg2 是一个完整的 options 对象，还是一个直接的插值参数对象
    const isOptionsObject =
      arg2.params !== undefined || // 包含 params 键
      arg2.default !== undefined || // 包含 default 键
      arg2.fallbackKey !== undefined || // 包含 fallbackKey 键
      arg2.ignoreMissing !== undefined; // 包含 ignoreMissing 键

    if (isOptionsObject) {
      // 如果 arg2 看起来像一个 options 对象
      finalOptions = { ...finalOptions, ...arg2 }; // 合并全局默认值和传入的选项
      if (arg2.default !== undefined) {
        finalDefaultValue = arg2.default; // 从 options 中获取默认值
      }
      finalInterpolationParams = {
        ...finalInterpolationParams,
        ...(arg2.params || {}),
      }; // 合并插值参数
    } else {
      // 如果 arg2 不像 options 对象，则视为直接的插值参数对象
      finalInterpolationParams = { ...finalInterpolationParams, ...arg2 }; // 合并全局默认参数和传入的参数
      if (arg3 && typeof arg3 === 'object') {
        finalOptions = { ...finalOptions, ...arg3 }; // 合并全局默认值和 arg3 中的选项
        if (arg3.default !== undefined) {
          finalDefaultValue = arg3.default; // 从 arg3 的 options 中获取默认值
        }
      }
    }
  }
  // 如果 arg2 未提供，则所有变量保持其初始默认值（finalDefaultValue 为 key，其他为空对象）

  // 从最终确定的 options 中解构出其他配置
  let { fallbackKey = '', ignoreMissing = false } = finalOptions;

  // 如果用户明确提供了默认值（不是键本身），则不使用全局回退键
  const hasExplicitDefault = finalDefaultValue !== key;
  if (hasExplicitDefault && fallbackKey === globalDefaults.fallbackKey) {
    fallbackKey = ''; // 清除全局回退键，优先使用用户提供的默认值
  }

  const { t, te } = i18n.global; // 直接访问 i18n 实例的全局翻译方法

  // 1. 优先检查主键是否存在
  if (te(key)) {
    return t(key, finalInterpolationParams); // 使用解析出的插值参数
  }

  // 2. 检查回退键是否可用
  if (fallbackKey && te(fallbackKey)) {
    return t(fallbackKey, finalInterpolationParams); // 使用解析出的插值参数
  }

  // 3. 处理缺失翻译的情况
  if (!ignoreMissing) {
    console.warn(`[i18n] Missing translation key: ${key}`);

    // 可以在此处集成缺失翻译的报告系统
    // reportMissingKey(key)
  }

  // 4. 返回默认值，支持变量插值
  return interpolateString(finalDefaultValue, finalInterpolationParams);
};

export const transPlaceholder = (key, defaultText, type = 'general') => {
  return smartTranslate(`common.message.placeholder.${type}`, '请输入{field}', {
    field: smartTranslate(key, defaultText),
  });
};

/**
 * 字符串插值函数
 * 支持 {variable} 格式的变量替换
 * @param {string} template - 模板字符串
 * @param {Object} params - 参数对象
 * @returns {string} 插值后的字符串
 */
function interpolateString(template, params = {}) {
  if (typeof template !== 'string') {
    return template;
  }

  return template.replace(/\{([^}]+)\}/g, (match, key) => {
    // 支持嵌套属性访问，如 {user.name}
    const value = getNestedValue(params, key.trim());
    return value !== undefined ? String(value) : match; // 如果找不到变量，保留原始占位符
  });
}

/**
 * 获取嵌套对象的值
 * @param {Object} obj - 对象
 * @param {string} path - 属性路径，如 'user.name'
 * @returns {*} 属性值
 */
function getNestedValue(obj, path) {
  return path.split('.').reduce((current, key) => {
    return current && current[key] !== undefined ? current[key] : undefined;
  }, obj);
}

/**
 * 设置全局默认配置
 * @param {Object} config - 全局配置
 * @param {string} [config.defaultFallbackKey] - 全局默认回退键
 * @param {boolean} [config.defaultIgnoreMissing] - 全局默认是否忽略缺失警告
 * @param {Object} [config.globalParams] - 全局默认参数
 */
export const setSmartTranslateDefaults = (config = {}) => {
  smartTranslate._defaults = {
    fallbackKey: config.defaultFallbackKey || '',
    ignoreMissing: config.defaultIgnoreMissing || false,
    globalParams: config.globalParams || {},
  };
};

/**
 * 获取当前全局默认配置
 * @returns {Object} 全局配置
 */
export const getSmartTranslateDefaults = () => {
  return (
    smartTranslate._defaults || {
      fallbackKey: '',
      ignoreMissing: false,
      globalParams: {},
    }
  );
};

// 在函数上添加默认配置存储
smartTranslate._defaults = {
  fallbackKey: '',
  ignoreMissing: true, // 如果不希望在控制台显示缺少的键，请将此设置为 true
  globalParams: {},
};

/**
 * 动态加载语言包
 * @param {string} locale 语言代码
 * @returns {Promise<void>}
 */
export async function loadLanguageAsync(locale) {
  // 检查是否已经加载 (内存缓存)
  if (i18n.global.availableLocales.includes(locale)) {
    console.log(`[i18n] Language ${locale} already in memory.`);
    return;
  }

  try {
    // 从 i18nLoader 加载翻译数据 (会通过 i18nLoader 内部的缓存逻辑)
    const messages = await i18nLoader.loadTranslations(locale);

    // 设置语言包
    i18n.global.setLocaleMessage(locale, messages);

    console.log(`[i18n] Language pack ${locale} loaded successfully.`);
  } catch (error) {
    console.error(`[i18n] Failed to load language pack ${locale}:`, error);

    // 如果加载失败，尝试加载默认语言
    if (locale !== DEFAULT_LOCALE) {
      console.log(
        `[i18n] Attempting to load default language ${DEFAULT_LOCALE}.`,
      );
      await loadLanguageAsync(DEFAULT_LOCALE);
    }
  }
}

/**
 * 切换语言
 * @param {string} locale 语言代码
 * @returns {Promise<void>}
 */
export async function setLanguage(locale) {
  // 先加载语言包
  await loadLanguageAsync(locale);

  // 设置当前语言
  i18n.global.locale.value = locale;

  // 保存到本地存储
  useAppStore().changeLanguage(locale);

  // 设置HTML lang属性
  document.querySelector('html').setAttribute('lang', locale);
}

/**
 * 获取当前语言
 * @returns {string}
 */
export function getCurrentLanguage() {
  return i18n.global.locale.value;
}

/**
 * 获取支持的语言列表
 * @returns {Promise<Array>}
 */
export async function getSupportedLanguages() {
  try {
    // 从 i18nLoader 获取支持的语言列表 (会通过内部缓存逻辑)
    return await i18nLoader.getLanguages();
  } catch (error) {
    console.error('Failed to get supported languages:', error);
    return [DEFAULT_LOCALE];
  }
}

/**
 * 初始化i18n
 * @returns {Promise<void>}
 */
export async function initI18n() {
  // 从本地存储获取语言设置
  const savedLanguage = useAppStore().language || DEFAULT_LOCALE;

  try {
    // 加载初始语言包
    await loadLanguageAsync(savedLanguage);

    // 设置当前语言
    i18n.global.locale.value = savedLanguage;

    // 设置HTML lang属性
    document.querySelector('html').setAttribute('lang', savedLanguage);

    console.log(`i18n初始化完成，当前语言: ${savedLanguage}`);
  } catch (error) {
    console.error('i18n初始化失败:', error);
  }
}

export default i18n;
